package com.sunny.fetch.pojo;

import java.util.ArrayList;
import java.util.List;

public class FIncomeExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public FIncomeExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andTidIsNull() {
            addCriterion("tid is null");
            return (Criteria) this;
        }

        public Criteria andTidIsNotNull() {
            addCriterion("tid is not null");
            return (Criteria) this;
        }

        public Criteria andTidEqualTo(Long value) {
            addCriterion("tid =", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotEqualTo(Long value) {
            addCriterion("tid <>", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidGreaterThan(Long value) {
            addCriterion("tid >", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidGreaterThanOrEqualTo(Long value) {
            addCriterion("tid >=", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidLessThan(Long value) {
            addCriterion("tid <", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidLessThanOrEqualTo(Long value) {
            addCriterion("tid <=", value, "tid");
            return (Criteria) this;
        }

        public Criteria andTidIn(List<Long> values) {
            addCriterion("tid in", values, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotIn(List<Long> values) {
            addCriterion("tid not in", values, "tid");
            return (Criteria) this;
        }

        public Criteria andTidBetween(Long value1, Long value2) {
            addCriterion("tid between", value1, value2, "tid");
            return (Criteria) this;
        }

        public Criteria andTidNotBetween(Long value1, Long value2) {
            addCriterion("tid not between", value1, value2, "tid");
            return (Criteria) this;
        }

        public Criteria andTsCodeIsNull() {
            addCriterion("ts_code is null");
            return (Criteria) this;
        }

        public Criteria andTsCodeIsNotNull() {
            addCriterion("ts_code is not null");
            return (Criteria) this;
        }

        public Criteria andTsCodeEqualTo(String value) {
            addCriterion("ts_code =", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotEqualTo(String value) {
            addCriterion("ts_code <>", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeGreaterThan(String value) {
            addCriterion("ts_code >", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeGreaterThanOrEqualTo(String value) {
            addCriterion("ts_code >=", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLessThan(String value) {
            addCriterion("ts_code <", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLessThanOrEqualTo(String value) {
            addCriterion("ts_code <=", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeLike(String value) {
            addCriterion("ts_code like", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotLike(String value) {
            addCriterion("ts_code not like", value, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeIn(List<String> values) {
            addCriterion("ts_code in", values, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotIn(List<String> values) {
            addCriterion("ts_code not in", values, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeBetween(String value1, String value2) {
            addCriterion("ts_code between", value1, value2, "tsCode");
            return (Criteria) this;
        }

        public Criteria andTsCodeNotBetween(String value1, String value2) {
            addCriterion("ts_code not between", value1, value2, "tsCode");
            return (Criteria) this;
        }

        public Criteria andAnnDateIsNull() {
            addCriterion("ann_date is null");
            return (Criteria) this;
        }

        public Criteria andAnnDateIsNotNull() {
            addCriterion("ann_date is not null");
            return (Criteria) this;
        }

        public Criteria andAnnDateEqualTo(String value) {
            addCriterion("ann_date =", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotEqualTo(String value) {
            addCriterion("ann_date <>", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateGreaterThan(String value) {
            addCriterion("ann_date >", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateGreaterThanOrEqualTo(String value) {
            addCriterion("ann_date >=", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLessThan(String value) {
            addCriterion("ann_date <", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLessThanOrEqualTo(String value) {
            addCriterion("ann_date <=", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateLike(String value) {
            addCriterion("ann_date like", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotLike(String value) {
            addCriterion("ann_date not like", value, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateIn(List<String> values) {
            addCriterion("ann_date in", values, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotIn(List<String> values) {
            addCriterion("ann_date not in", values, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateBetween(String value1, String value2) {
            addCriterion("ann_date between", value1, value2, "annDate");
            return (Criteria) this;
        }

        public Criteria andAnnDateNotBetween(String value1, String value2) {
            addCriterion("ann_date not between", value1, value2, "annDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateIsNull() {
            addCriterion("f_ann_date is null");
            return (Criteria) this;
        }

        public Criteria andFAnnDateIsNotNull() {
            addCriterion("f_ann_date is not null");
            return (Criteria) this;
        }

        public Criteria andFAnnDateEqualTo(String value) {
            addCriterion("f_ann_date =", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotEqualTo(String value) {
            addCriterion("f_ann_date <>", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateGreaterThan(String value) {
            addCriterion("f_ann_date >", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateGreaterThanOrEqualTo(String value) {
            addCriterion("f_ann_date >=", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateLessThan(String value) {
            addCriterion("f_ann_date <", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateLessThanOrEqualTo(String value) {
            addCriterion("f_ann_date <=", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateLike(String value) {
            addCriterion("f_ann_date like", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotLike(String value) {
            addCriterion("f_ann_date not like", value, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateIn(List<String> values) {
            addCriterion("f_ann_date in", values, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotIn(List<String> values) {
            addCriterion("f_ann_date not in", values, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateBetween(String value1, String value2) {
            addCriterion("f_ann_date between", value1, value2, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andFAnnDateNotBetween(String value1, String value2) {
            addCriterion("f_ann_date not between", value1, value2, "fAnnDate");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNull() {
            addCriterion("end_date is null");
            return (Criteria) this;
        }

        public Criteria andEndDateIsNotNull() {
            addCriterion("end_date is not null");
            return (Criteria) this;
        }

        public Criteria andEndDateEqualTo(String value) {
            addCriterion("end_date =", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotEqualTo(String value) {
            addCriterion("end_date <>", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThan(String value) {
            addCriterion("end_date >", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(String value) {
            addCriterion("end_date >=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThan(String value) {
            addCriterion("end_date <", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLessThanOrEqualTo(String value) {
            addCriterion("end_date <=", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateLike(String value) {
            addCriterion("end_date like", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotLike(String value) {
            addCriterion("end_date not like", value, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateIn(List<String> values) {
            addCriterion("end_date in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotIn(List<String> values) {
            addCriterion("end_date not in", values, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateBetween(String value1, String value2) {
            addCriterion("end_date between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andEndDateNotBetween(String value1, String value2) {
            addCriterion("end_date not between", value1, value2, "endDate");
            return (Criteria) this;
        }

        public Criteria andReportTypeIsNull() {
            addCriterion("report_type is null");
            return (Criteria) this;
        }

        public Criteria andReportTypeIsNotNull() {
            addCriterion("report_type is not null");
            return (Criteria) this;
        }

        public Criteria andReportTypeEqualTo(String value) {
            addCriterion("report_type =", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotEqualTo(String value) {
            addCriterion("report_type <>", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeGreaterThan(String value) {
            addCriterion("report_type >", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeGreaterThanOrEqualTo(String value) {
            addCriterion("report_type >=", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeLessThan(String value) {
            addCriterion("report_type <", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeLessThanOrEqualTo(String value) {
            addCriterion("report_type <=", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeLike(String value) {
            addCriterion("report_type like", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotLike(String value) {
            addCriterion("report_type not like", value, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeIn(List<String> values) {
            addCriterion("report_type in", values, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotIn(List<String> values) {
            addCriterion("report_type not in", values, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeBetween(String value1, String value2) {
            addCriterion("report_type between", value1, value2, "reportType");
            return (Criteria) this;
        }

        public Criteria andReportTypeNotBetween(String value1, String value2) {
            addCriterion("report_type not between", value1, value2, "reportType");
            return (Criteria) this;
        }

        public Criteria andCompTypeIsNull() {
            addCriterion("comp_type is null");
            return (Criteria) this;
        }

        public Criteria andCompTypeIsNotNull() {
            addCriterion("comp_type is not null");
            return (Criteria) this;
        }

        public Criteria andCompTypeEqualTo(String value) {
            addCriterion("comp_type =", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotEqualTo(String value) {
            addCriterion("comp_type <>", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeGreaterThan(String value) {
            addCriterion("comp_type >", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeGreaterThanOrEqualTo(String value) {
            addCriterion("comp_type >=", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeLessThan(String value) {
            addCriterion("comp_type <", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeLessThanOrEqualTo(String value) {
            addCriterion("comp_type <=", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeLike(String value) {
            addCriterion("comp_type like", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotLike(String value) {
            addCriterion("comp_type not like", value, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeIn(List<String> values) {
            addCriterion("comp_type in", values, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotIn(List<String> values) {
            addCriterion("comp_type not in", values, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeBetween(String value1, String value2) {
            addCriterion("comp_type between", value1, value2, "compType");
            return (Criteria) this;
        }

        public Criteria andCompTypeNotBetween(String value1, String value2) {
            addCriterion("comp_type not between", value1, value2, "compType");
            return (Criteria) this;
        }

        public Criteria andBasicEpsIsNull() {
            addCriterion("basic_eps is null");
            return (Criteria) this;
        }

        public Criteria andBasicEpsIsNotNull() {
            addCriterion("basic_eps is not null");
            return (Criteria) this;
        }

        public Criteria andBasicEpsEqualTo(Float value) {
            addCriterion("basic_eps =", value, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsNotEqualTo(Float value) {
            addCriterion("basic_eps <>", value, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsGreaterThan(Float value) {
            addCriterion("basic_eps >", value, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsGreaterThanOrEqualTo(Float value) {
            addCriterion("basic_eps >=", value, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsLessThan(Float value) {
            addCriterion("basic_eps <", value, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsLessThanOrEqualTo(Float value) {
            addCriterion("basic_eps <=", value, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsIn(List<Float> values) {
            addCriterion("basic_eps in", values, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsNotIn(List<Float> values) {
            addCriterion("basic_eps not in", values, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsBetween(Float value1, Float value2) {
            addCriterion("basic_eps between", value1, value2, "basicEps");
            return (Criteria) this;
        }

        public Criteria andBasicEpsNotBetween(Float value1, Float value2) {
            addCriterion("basic_eps not between", value1, value2, "basicEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsIsNull() {
            addCriterion("diluted_eps is null");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsIsNotNull() {
            addCriterion("diluted_eps is not null");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsEqualTo(Float value) {
            addCriterion("diluted_eps =", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsNotEqualTo(Float value) {
            addCriterion("diluted_eps <>", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsGreaterThan(Float value) {
            addCriterion("diluted_eps >", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsGreaterThanOrEqualTo(Float value) {
            addCriterion("diluted_eps >=", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsLessThan(Float value) {
            addCriterion("diluted_eps <", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsLessThanOrEqualTo(Float value) {
            addCriterion("diluted_eps <=", value, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsIn(List<Float> values) {
            addCriterion("diluted_eps in", values, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsNotIn(List<Float> values) {
            addCriterion("diluted_eps not in", values, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsBetween(Float value1, Float value2) {
            addCriterion("diluted_eps between", value1, value2, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andDilutedEpsNotBetween(Float value1, Float value2) {
            addCriterion("diluted_eps not between", value1, value2, "dilutedEps");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueIsNull() {
            addCriterion("total_revenue is null");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueIsNotNull() {
            addCriterion("total_revenue is not null");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueEqualTo(Float value) {
            addCriterion("total_revenue =", value, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueNotEqualTo(Float value) {
            addCriterion("total_revenue <>", value, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueGreaterThan(Float value) {
            addCriterion("total_revenue >", value, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueGreaterThanOrEqualTo(Float value) {
            addCriterion("total_revenue >=", value, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueLessThan(Float value) {
            addCriterion("total_revenue <", value, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueLessThanOrEqualTo(Float value) {
            addCriterion("total_revenue <=", value, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueIn(List<Float> values) {
            addCriterion("total_revenue in", values, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueNotIn(List<Float> values) {
            addCriterion("total_revenue not in", values, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueBetween(Float value1, Float value2) {
            addCriterion("total_revenue between", value1, value2, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andTotalRevenueNotBetween(Float value1, Float value2) {
            addCriterion("total_revenue not between", value1, value2, "totalRevenue");
            return (Criteria) this;
        }

        public Criteria andRevenueIsNull() {
            addCriterion("revenue is null");
            return (Criteria) this;
        }

        public Criteria andRevenueIsNotNull() {
            addCriterion("revenue is not null");
            return (Criteria) this;
        }

        public Criteria andRevenueEqualTo(Float value) {
            addCriterion("revenue =", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueNotEqualTo(Float value) {
            addCriterion("revenue <>", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueGreaterThan(Float value) {
            addCriterion("revenue >", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueGreaterThanOrEqualTo(Float value) {
            addCriterion("revenue >=", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueLessThan(Float value) {
            addCriterion("revenue <", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueLessThanOrEqualTo(Float value) {
            addCriterion("revenue <=", value, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueIn(List<Float> values) {
            addCriterion("revenue in", values, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueNotIn(List<Float> values) {
            addCriterion("revenue not in", values, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueBetween(Float value1, Float value2) {
            addCriterion("revenue between", value1, value2, "revenue");
            return (Criteria) this;
        }

        public Criteria andRevenueNotBetween(Float value1, Float value2) {
            addCriterion("revenue not between", value1, value2, "revenue");
            return (Criteria) this;
        }

        public Criteria andIntIncomeIsNull() {
            addCriterion("int_income is null");
            return (Criteria) this;
        }

        public Criteria andIntIncomeIsNotNull() {
            addCriterion("int_income is not null");
            return (Criteria) this;
        }

        public Criteria andIntIncomeEqualTo(Float value) {
            addCriterion("int_income =", value, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeNotEqualTo(Float value) {
            addCriterion("int_income <>", value, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeGreaterThan(Float value) {
            addCriterion("int_income >", value, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("int_income >=", value, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeLessThan(Float value) {
            addCriterion("int_income <", value, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeLessThanOrEqualTo(Float value) {
            addCriterion("int_income <=", value, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeIn(List<Float> values) {
            addCriterion("int_income in", values, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeNotIn(List<Float> values) {
            addCriterion("int_income not in", values, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeBetween(Float value1, Float value2) {
            addCriterion("int_income between", value1, value2, "intIncome");
            return (Criteria) this;
        }

        public Criteria andIntIncomeNotBetween(Float value1, Float value2) {
            addCriterion("int_income not between", value1, value2, "intIncome");
            return (Criteria) this;
        }

        public Criteria andPremEarnedIsNull() {
            addCriterion("prem_earned is null");
            return (Criteria) this;
        }

        public Criteria andPremEarnedIsNotNull() {
            addCriterion("prem_earned is not null");
            return (Criteria) this;
        }

        public Criteria andPremEarnedEqualTo(Float value) {
            addCriterion("prem_earned =", value, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedNotEqualTo(Float value) {
            addCriterion("prem_earned <>", value, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedGreaterThan(Float value) {
            addCriterion("prem_earned >", value, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedGreaterThanOrEqualTo(Float value) {
            addCriterion("prem_earned >=", value, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedLessThan(Float value) {
            addCriterion("prem_earned <", value, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedLessThanOrEqualTo(Float value) {
            addCriterion("prem_earned <=", value, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedIn(List<Float> values) {
            addCriterion("prem_earned in", values, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedNotIn(List<Float> values) {
            addCriterion("prem_earned not in", values, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedBetween(Float value1, Float value2) {
            addCriterion("prem_earned between", value1, value2, "premEarned");
            return (Criteria) this;
        }

        public Criteria andPremEarnedNotBetween(Float value1, Float value2) {
            addCriterion("prem_earned not between", value1, value2, "premEarned");
            return (Criteria) this;
        }

        public Criteria andCommIncomeIsNull() {
            addCriterion("comm_income is null");
            return (Criteria) this;
        }

        public Criteria andCommIncomeIsNotNull() {
            addCriterion("comm_income is not null");
            return (Criteria) this;
        }

        public Criteria andCommIncomeEqualTo(Float value) {
            addCriterion("comm_income =", value, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeNotEqualTo(Float value) {
            addCriterion("comm_income <>", value, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeGreaterThan(Float value) {
            addCriterion("comm_income >", value, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("comm_income >=", value, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeLessThan(Float value) {
            addCriterion("comm_income <", value, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeLessThanOrEqualTo(Float value) {
            addCriterion("comm_income <=", value, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeIn(List<Float> values) {
            addCriterion("comm_income in", values, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeNotIn(List<Float> values) {
            addCriterion("comm_income not in", values, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeBetween(Float value1, Float value2) {
            addCriterion("comm_income between", value1, value2, "commIncome");
            return (Criteria) this;
        }

        public Criteria andCommIncomeNotBetween(Float value1, Float value2) {
            addCriterion("comm_income not between", value1, value2, "commIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeIsNull() {
            addCriterion("n_commis_income is null");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeIsNotNull() {
            addCriterion("n_commis_income is not null");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeEqualTo(Float value) {
            addCriterion("n_commis_income =", value, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeNotEqualTo(Float value) {
            addCriterion("n_commis_income <>", value, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeGreaterThan(Float value) {
            addCriterion("n_commis_income >", value, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_commis_income >=", value, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeLessThan(Float value) {
            addCriterion("n_commis_income <", value, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_commis_income <=", value, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeIn(List<Float> values) {
            addCriterion("n_commis_income in", values, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeNotIn(List<Float> values) {
            addCriterion("n_commis_income not in", values, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeBetween(Float value1, Float value2) {
            addCriterion("n_commis_income between", value1, value2, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNCommisIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_commis_income not between", value1, value2, "nCommisIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeIsNull() {
            addCriterion("n_oth_income is null");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeIsNotNull() {
            addCriterion("n_oth_income is not null");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeEqualTo(Float value) {
            addCriterion("n_oth_income =", value, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeNotEqualTo(Float value) {
            addCriterion("n_oth_income <>", value, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeGreaterThan(Float value) {
            addCriterion("n_oth_income >", value, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_oth_income >=", value, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeLessThan(Float value) {
            addCriterion("n_oth_income <", value, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_oth_income <=", value, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeIn(List<Float> values) {
            addCriterion("n_oth_income in", values, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeNotIn(List<Float> values) {
            addCriterion("n_oth_income not in", values, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeBetween(Float value1, Float value2) {
            addCriterion("n_oth_income between", value1, value2, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_oth_income not between", value1, value2, "nOthIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeIsNull() {
            addCriterion("n_oth_b_income is null");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeIsNotNull() {
            addCriterion("n_oth_b_income is not null");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeEqualTo(Float value) {
            addCriterion("n_oth_b_income =", value, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeNotEqualTo(Float value) {
            addCriterion("n_oth_b_income <>", value, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeGreaterThan(Float value) {
            addCriterion("n_oth_b_income >", value, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_oth_b_income >=", value, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeLessThan(Float value) {
            addCriterion("n_oth_b_income <", value, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_oth_b_income <=", value, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeIn(List<Float> values) {
            addCriterion("n_oth_b_income in", values, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeNotIn(List<Float> values) {
            addCriterion("n_oth_b_income not in", values, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeBetween(Float value1, Float value2) {
            addCriterion("n_oth_b_income between", value1, value2, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andNOthBIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_oth_b_income not between", value1, value2, "nOthBIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeIsNull() {
            addCriterion("prem_income is null");
            return (Criteria) this;
        }

        public Criteria andPremIncomeIsNotNull() {
            addCriterion("prem_income is not null");
            return (Criteria) this;
        }

        public Criteria andPremIncomeEqualTo(Float value) {
            addCriterion("prem_income =", value, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeNotEqualTo(Float value) {
            addCriterion("prem_income <>", value, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeGreaterThan(Float value) {
            addCriterion("prem_income >", value, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("prem_income >=", value, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeLessThan(Float value) {
            addCriterion("prem_income <", value, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeLessThanOrEqualTo(Float value) {
            addCriterion("prem_income <=", value, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeIn(List<Float> values) {
            addCriterion("prem_income in", values, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeNotIn(List<Float> values) {
            addCriterion("prem_income not in", values, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeBetween(Float value1, Float value2) {
            addCriterion("prem_income between", value1, value2, "premIncome");
            return (Criteria) this;
        }

        public Criteria andPremIncomeNotBetween(Float value1, Float value2) {
            addCriterion("prem_income not between", value1, value2, "premIncome");
            return (Criteria) this;
        }

        public Criteria andOutPremIsNull() {
            addCriterion("out_prem is null");
            return (Criteria) this;
        }

        public Criteria andOutPremIsNotNull() {
            addCriterion("out_prem is not null");
            return (Criteria) this;
        }

        public Criteria andOutPremEqualTo(Float value) {
            addCriterion("out_prem =", value, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremNotEqualTo(Float value) {
            addCriterion("out_prem <>", value, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremGreaterThan(Float value) {
            addCriterion("out_prem >", value, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremGreaterThanOrEqualTo(Float value) {
            addCriterion("out_prem >=", value, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremLessThan(Float value) {
            addCriterion("out_prem <", value, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremLessThanOrEqualTo(Float value) {
            addCriterion("out_prem <=", value, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremIn(List<Float> values) {
            addCriterion("out_prem in", values, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremNotIn(List<Float> values) {
            addCriterion("out_prem not in", values, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremBetween(Float value1, Float value2) {
            addCriterion("out_prem between", value1, value2, "outPrem");
            return (Criteria) this;
        }

        public Criteria andOutPremNotBetween(Float value1, Float value2) {
            addCriterion("out_prem not between", value1, value2, "outPrem");
            return (Criteria) this;
        }

        public Criteria andUnePremReserIsNull() {
            addCriterion("une_prem_reser is null");
            return (Criteria) this;
        }

        public Criteria andUnePremReserIsNotNull() {
            addCriterion("une_prem_reser is not null");
            return (Criteria) this;
        }

        public Criteria andUnePremReserEqualTo(Float value) {
            addCriterion("une_prem_reser =", value, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserNotEqualTo(Float value) {
            addCriterion("une_prem_reser <>", value, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserGreaterThan(Float value) {
            addCriterion("une_prem_reser >", value, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserGreaterThanOrEqualTo(Float value) {
            addCriterion("une_prem_reser >=", value, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserLessThan(Float value) {
            addCriterion("une_prem_reser <", value, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserLessThanOrEqualTo(Float value) {
            addCriterion("une_prem_reser <=", value, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserIn(List<Float> values) {
            addCriterion("une_prem_reser in", values, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserNotIn(List<Float> values) {
            addCriterion("une_prem_reser not in", values, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserBetween(Float value1, Float value2) {
            addCriterion("une_prem_reser between", value1, value2, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andUnePremReserNotBetween(Float value1, Float value2) {
            addCriterion("une_prem_reser not between", value1, value2, "unePremReser");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeIsNull() {
            addCriterion("reins_income is null");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeIsNotNull() {
            addCriterion("reins_income is not null");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeEqualTo(Float value) {
            addCriterion("reins_income =", value, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeNotEqualTo(Float value) {
            addCriterion("reins_income <>", value, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeGreaterThan(Float value) {
            addCriterion("reins_income >", value, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("reins_income >=", value, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeLessThan(Float value) {
            addCriterion("reins_income <", value, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeLessThanOrEqualTo(Float value) {
            addCriterion("reins_income <=", value, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeIn(List<Float> values) {
            addCriterion("reins_income in", values, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeNotIn(List<Float> values) {
            addCriterion("reins_income not in", values, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeBetween(Float value1, Float value2) {
            addCriterion("reins_income between", value1, value2, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andReinsIncomeNotBetween(Float value1, Float value2) {
            addCriterion("reins_income not between", value1, value2, "reinsIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeIsNull() {
            addCriterion("n_sec_tb_income is null");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeIsNotNull() {
            addCriterion("n_sec_tb_income is not null");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeEqualTo(Float value) {
            addCriterion("n_sec_tb_income =", value, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeNotEqualTo(Float value) {
            addCriterion("n_sec_tb_income <>", value, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeGreaterThan(Float value) {
            addCriterion("n_sec_tb_income >", value, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_sec_tb_income >=", value, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeLessThan(Float value) {
            addCriterion("n_sec_tb_income <", value, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_sec_tb_income <=", value, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeIn(List<Float> values) {
            addCriterion("n_sec_tb_income in", values, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeNotIn(List<Float> values) {
            addCriterion("n_sec_tb_income not in", values, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeBetween(Float value1, Float value2) {
            addCriterion("n_sec_tb_income between", value1, value2, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecTbIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_sec_tb_income not between", value1, value2, "nSecTbIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeIsNull() {
            addCriterion("n_sec_uw_income is null");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeIsNotNull() {
            addCriterion("n_sec_uw_income is not null");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeEqualTo(Float value) {
            addCriterion("n_sec_uw_income =", value, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeNotEqualTo(Float value) {
            addCriterion("n_sec_uw_income <>", value, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeGreaterThan(Float value) {
            addCriterion("n_sec_uw_income >", value, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_sec_uw_income >=", value, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeLessThan(Float value) {
            addCriterion("n_sec_uw_income <", value, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_sec_uw_income <=", value, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeIn(List<Float> values) {
            addCriterion("n_sec_uw_income in", values, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeNotIn(List<Float> values) {
            addCriterion("n_sec_uw_income not in", values, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeBetween(Float value1, Float value2) {
            addCriterion("n_sec_uw_income between", value1, value2, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNSecUwIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_sec_uw_income not between", value1, value2, "nSecUwIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeIsNull() {
            addCriterion("n_asset_mg_income is null");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeIsNotNull() {
            addCriterion("n_asset_mg_income is not null");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeEqualTo(Float value) {
            addCriterion("n_asset_mg_income =", value, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeNotEqualTo(Float value) {
            addCriterion("n_asset_mg_income <>", value, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeGreaterThan(Float value) {
            addCriterion("n_asset_mg_income >", value, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_asset_mg_income >=", value, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeLessThan(Float value) {
            addCriterion("n_asset_mg_income <", value, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_asset_mg_income <=", value, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeIn(List<Float> values) {
            addCriterion("n_asset_mg_income in", values, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeNotIn(List<Float> values) {
            addCriterion("n_asset_mg_income not in", values, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeBetween(Float value1, Float value2) {
            addCriterion("n_asset_mg_income between", value1, value2, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andNAssetMgIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_asset_mg_income not between", value1, value2, "nAssetMgIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeIsNull() {
            addCriterion("oth_b_income is null");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeIsNotNull() {
            addCriterion("oth_b_income is not null");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeEqualTo(Float value) {
            addCriterion("oth_b_income =", value, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeNotEqualTo(Float value) {
            addCriterion("oth_b_income <>", value, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeGreaterThan(Float value) {
            addCriterion("oth_b_income >", value, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_b_income >=", value, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeLessThan(Float value) {
            addCriterion("oth_b_income <", value, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeLessThanOrEqualTo(Float value) {
            addCriterion("oth_b_income <=", value, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeIn(List<Float> values) {
            addCriterion("oth_b_income in", values, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeNotIn(List<Float> values) {
            addCriterion("oth_b_income not in", values, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeBetween(Float value1, Float value2) {
            addCriterion("oth_b_income between", value1, value2, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andOthBIncomeNotBetween(Float value1, Float value2) {
            addCriterion("oth_b_income not between", value1, value2, "othBIncome");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainIsNull() {
            addCriterion("fv_value_chg_gain is null");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainIsNotNull() {
            addCriterion("fv_value_chg_gain is not null");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainEqualTo(Float value) {
            addCriterion("fv_value_chg_gain =", value, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainNotEqualTo(Float value) {
            addCriterion("fv_value_chg_gain <>", value, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainGreaterThan(Float value) {
            addCriterion("fv_value_chg_gain >", value, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainGreaterThanOrEqualTo(Float value) {
            addCriterion("fv_value_chg_gain >=", value, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainLessThan(Float value) {
            addCriterion("fv_value_chg_gain <", value, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainLessThanOrEqualTo(Float value) {
            addCriterion("fv_value_chg_gain <=", value, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainIn(List<Float> values) {
            addCriterion("fv_value_chg_gain in", values, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainNotIn(List<Float> values) {
            addCriterion("fv_value_chg_gain not in", values, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainBetween(Float value1, Float value2) {
            addCriterion("fv_value_chg_gain between", value1, value2, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andFvValueChgGainNotBetween(Float value1, Float value2) {
            addCriterion("fv_value_chg_gain not between", value1, value2, "fvValueChgGain");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeIsNull() {
            addCriterion("invest_income is null");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeIsNotNull() {
            addCriterion("invest_income is not null");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeEqualTo(Float value) {
            addCriterion("invest_income =", value, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeNotEqualTo(Float value) {
            addCriterion("invest_income <>", value, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeGreaterThan(Float value) {
            addCriterion("invest_income >", value, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("invest_income >=", value, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeLessThan(Float value) {
            addCriterion("invest_income <", value, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeLessThanOrEqualTo(Float value) {
            addCriterion("invest_income <=", value, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeIn(List<Float> values) {
            addCriterion("invest_income in", values, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeNotIn(List<Float> values) {
            addCriterion("invest_income not in", values, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeBetween(Float value1, Float value2) {
            addCriterion("invest_income between", value1, value2, "investIncome");
            return (Criteria) this;
        }

        public Criteria andInvestIncomeNotBetween(Float value1, Float value2) {
            addCriterion("invest_income not between", value1, value2, "investIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeIsNull() {
            addCriterion("ass_invest_income is null");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeIsNotNull() {
            addCriterion("ass_invest_income is not null");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeEqualTo(Float value) {
            addCriterion("ass_invest_income =", value, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeNotEqualTo(Float value) {
            addCriterion("ass_invest_income <>", value, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeGreaterThan(Float value) {
            addCriterion("ass_invest_income >", value, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("ass_invest_income >=", value, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeLessThan(Float value) {
            addCriterion("ass_invest_income <", value, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeLessThanOrEqualTo(Float value) {
            addCriterion("ass_invest_income <=", value, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeIn(List<Float> values) {
            addCriterion("ass_invest_income in", values, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeNotIn(List<Float> values) {
            addCriterion("ass_invest_income not in", values, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeBetween(Float value1, Float value2) {
            addCriterion("ass_invest_income between", value1, value2, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andAssInvestIncomeNotBetween(Float value1, Float value2) {
            addCriterion("ass_invest_income not between", value1, value2, "assInvestIncome");
            return (Criteria) this;
        }

        public Criteria andForexGainIsNull() {
            addCriterion("forex_gain is null");
            return (Criteria) this;
        }

        public Criteria andForexGainIsNotNull() {
            addCriterion("forex_gain is not null");
            return (Criteria) this;
        }

        public Criteria andForexGainEqualTo(Float value) {
            addCriterion("forex_gain =", value, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainNotEqualTo(Float value) {
            addCriterion("forex_gain <>", value, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainGreaterThan(Float value) {
            addCriterion("forex_gain >", value, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainGreaterThanOrEqualTo(Float value) {
            addCriterion("forex_gain >=", value, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainLessThan(Float value) {
            addCriterion("forex_gain <", value, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainLessThanOrEqualTo(Float value) {
            addCriterion("forex_gain <=", value, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainIn(List<Float> values) {
            addCriterion("forex_gain in", values, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainNotIn(List<Float> values) {
            addCriterion("forex_gain not in", values, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainBetween(Float value1, Float value2) {
            addCriterion("forex_gain between", value1, value2, "forexGain");
            return (Criteria) this;
        }

        public Criteria andForexGainNotBetween(Float value1, Float value2) {
            addCriterion("forex_gain not between", value1, value2, "forexGain");
            return (Criteria) this;
        }

        public Criteria andTotalCogsIsNull() {
            addCriterion("total_cogs is null");
            return (Criteria) this;
        }

        public Criteria andTotalCogsIsNotNull() {
            addCriterion("total_cogs is not null");
            return (Criteria) this;
        }

        public Criteria andTotalCogsEqualTo(Float value) {
            addCriterion("total_cogs =", value, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsNotEqualTo(Float value) {
            addCriterion("total_cogs <>", value, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsGreaterThan(Float value) {
            addCriterion("total_cogs >", value, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsGreaterThanOrEqualTo(Float value) {
            addCriterion("total_cogs >=", value, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsLessThan(Float value) {
            addCriterion("total_cogs <", value, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsLessThanOrEqualTo(Float value) {
            addCriterion("total_cogs <=", value, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsIn(List<Float> values) {
            addCriterion("total_cogs in", values, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsNotIn(List<Float> values) {
            addCriterion("total_cogs not in", values, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsBetween(Float value1, Float value2) {
            addCriterion("total_cogs between", value1, value2, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andTotalCogsNotBetween(Float value1, Float value2) {
            addCriterion("total_cogs not between", value1, value2, "totalCogs");
            return (Criteria) this;
        }

        public Criteria andOperCostIsNull() {
            addCriterion("oper_cost is null");
            return (Criteria) this;
        }

        public Criteria andOperCostIsNotNull() {
            addCriterion("oper_cost is not null");
            return (Criteria) this;
        }

        public Criteria andOperCostEqualTo(Float value) {
            addCriterion("oper_cost =", value, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostNotEqualTo(Float value) {
            addCriterion("oper_cost <>", value, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostGreaterThan(Float value) {
            addCriterion("oper_cost >", value, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostGreaterThanOrEqualTo(Float value) {
            addCriterion("oper_cost >=", value, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostLessThan(Float value) {
            addCriterion("oper_cost <", value, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostLessThanOrEqualTo(Float value) {
            addCriterion("oper_cost <=", value, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostIn(List<Float> values) {
            addCriterion("oper_cost in", values, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostNotIn(List<Float> values) {
            addCriterion("oper_cost not in", values, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostBetween(Float value1, Float value2) {
            addCriterion("oper_cost between", value1, value2, "operCost");
            return (Criteria) this;
        }

        public Criteria andOperCostNotBetween(Float value1, Float value2) {
            addCriterion("oper_cost not between", value1, value2, "operCost");
            return (Criteria) this;
        }

        public Criteria andIntExpIsNull() {
            addCriterion("int_exp is null");
            return (Criteria) this;
        }

        public Criteria andIntExpIsNotNull() {
            addCriterion("int_exp is not null");
            return (Criteria) this;
        }

        public Criteria andIntExpEqualTo(Float value) {
            addCriterion("int_exp =", value, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpNotEqualTo(Float value) {
            addCriterion("int_exp <>", value, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpGreaterThan(Float value) {
            addCriterion("int_exp >", value, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpGreaterThanOrEqualTo(Float value) {
            addCriterion("int_exp >=", value, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpLessThan(Float value) {
            addCriterion("int_exp <", value, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpLessThanOrEqualTo(Float value) {
            addCriterion("int_exp <=", value, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpIn(List<Float> values) {
            addCriterion("int_exp in", values, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpNotIn(List<Float> values) {
            addCriterion("int_exp not in", values, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpBetween(Float value1, Float value2) {
            addCriterion("int_exp between", value1, value2, "intExp");
            return (Criteria) this;
        }

        public Criteria andIntExpNotBetween(Float value1, Float value2) {
            addCriterion("int_exp not between", value1, value2, "intExp");
            return (Criteria) this;
        }

        public Criteria andCommExpIsNull() {
            addCriterion("comm_exp is null");
            return (Criteria) this;
        }

        public Criteria andCommExpIsNotNull() {
            addCriterion("comm_exp is not null");
            return (Criteria) this;
        }

        public Criteria andCommExpEqualTo(Float value) {
            addCriterion("comm_exp =", value, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpNotEqualTo(Float value) {
            addCriterion("comm_exp <>", value, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpGreaterThan(Float value) {
            addCriterion("comm_exp >", value, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpGreaterThanOrEqualTo(Float value) {
            addCriterion("comm_exp >=", value, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpLessThan(Float value) {
            addCriterion("comm_exp <", value, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpLessThanOrEqualTo(Float value) {
            addCriterion("comm_exp <=", value, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpIn(List<Float> values) {
            addCriterion("comm_exp in", values, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpNotIn(List<Float> values) {
            addCriterion("comm_exp not in", values, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpBetween(Float value1, Float value2) {
            addCriterion("comm_exp between", value1, value2, "commExp");
            return (Criteria) this;
        }

        public Criteria andCommExpNotBetween(Float value1, Float value2) {
            addCriterion("comm_exp not between", value1, value2, "commExp");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgIsNull() {
            addCriterion("biz_tax_surchg is null");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgIsNotNull() {
            addCriterion("biz_tax_surchg is not null");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgEqualTo(Float value) {
            addCriterion("biz_tax_surchg =", value, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgNotEqualTo(Float value) {
            addCriterion("biz_tax_surchg <>", value, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgGreaterThan(Float value) {
            addCriterion("biz_tax_surchg >", value, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgGreaterThanOrEqualTo(Float value) {
            addCriterion("biz_tax_surchg >=", value, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgLessThan(Float value) {
            addCriterion("biz_tax_surchg <", value, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgLessThanOrEqualTo(Float value) {
            addCriterion("biz_tax_surchg <=", value, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgIn(List<Float> values) {
            addCriterion("biz_tax_surchg in", values, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgNotIn(List<Float> values) {
            addCriterion("biz_tax_surchg not in", values, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgBetween(Float value1, Float value2) {
            addCriterion("biz_tax_surchg between", value1, value2, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andBizTaxSurchgNotBetween(Float value1, Float value2) {
            addCriterion("biz_tax_surchg not between", value1, value2, "bizTaxSurchg");
            return (Criteria) this;
        }

        public Criteria andSellExpIsNull() {
            addCriterion("sell_exp is null");
            return (Criteria) this;
        }

        public Criteria andSellExpIsNotNull() {
            addCriterion("sell_exp is not null");
            return (Criteria) this;
        }

        public Criteria andSellExpEqualTo(Float value) {
            addCriterion("sell_exp =", value, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpNotEqualTo(Float value) {
            addCriterion("sell_exp <>", value, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpGreaterThan(Float value) {
            addCriterion("sell_exp >", value, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpGreaterThanOrEqualTo(Float value) {
            addCriterion("sell_exp >=", value, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpLessThan(Float value) {
            addCriterion("sell_exp <", value, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpLessThanOrEqualTo(Float value) {
            addCriterion("sell_exp <=", value, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpIn(List<Float> values) {
            addCriterion("sell_exp in", values, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpNotIn(List<Float> values) {
            addCriterion("sell_exp not in", values, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpBetween(Float value1, Float value2) {
            addCriterion("sell_exp between", value1, value2, "sellExp");
            return (Criteria) this;
        }

        public Criteria andSellExpNotBetween(Float value1, Float value2) {
            addCriterion("sell_exp not between", value1, value2, "sellExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpIsNull() {
            addCriterion("admin_exp is null");
            return (Criteria) this;
        }

        public Criteria andAdminExpIsNotNull() {
            addCriterion("admin_exp is not null");
            return (Criteria) this;
        }

        public Criteria andAdminExpEqualTo(Float value) {
            addCriterion("admin_exp =", value, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpNotEqualTo(Float value) {
            addCriterion("admin_exp <>", value, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpGreaterThan(Float value) {
            addCriterion("admin_exp >", value, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpGreaterThanOrEqualTo(Float value) {
            addCriterion("admin_exp >=", value, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpLessThan(Float value) {
            addCriterion("admin_exp <", value, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpLessThanOrEqualTo(Float value) {
            addCriterion("admin_exp <=", value, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpIn(List<Float> values) {
            addCriterion("admin_exp in", values, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpNotIn(List<Float> values) {
            addCriterion("admin_exp not in", values, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpBetween(Float value1, Float value2) {
            addCriterion("admin_exp between", value1, value2, "adminExp");
            return (Criteria) this;
        }

        public Criteria andAdminExpNotBetween(Float value1, Float value2) {
            addCriterion("admin_exp not between", value1, value2, "adminExp");
            return (Criteria) this;
        }

        public Criteria andFinExpIsNull() {
            addCriterion("fin_exp is null");
            return (Criteria) this;
        }

        public Criteria andFinExpIsNotNull() {
            addCriterion("fin_exp is not null");
            return (Criteria) this;
        }

        public Criteria andFinExpEqualTo(Float value) {
            addCriterion("fin_exp =", value, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpNotEqualTo(Float value) {
            addCriterion("fin_exp <>", value, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpGreaterThan(Float value) {
            addCriterion("fin_exp >", value, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpGreaterThanOrEqualTo(Float value) {
            addCriterion("fin_exp >=", value, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpLessThan(Float value) {
            addCriterion("fin_exp <", value, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpLessThanOrEqualTo(Float value) {
            addCriterion("fin_exp <=", value, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpIn(List<Float> values) {
            addCriterion("fin_exp in", values, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpNotIn(List<Float> values) {
            addCriterion("fin_exp not in", values, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpBetween(Float value1, Float value2) {
            addCriterion("fin_exp between", value1, value2, "finExp");
            return (Criteria) this;
        }

        public Criteria andFinExpNotBetween(Float value1, Float value2) {
            addCriterion("fin_exp not between", value1, value2, "finExp");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossIsNull() {
            addCriterion("assets_impair_loss is null");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossIsNotNull() {
            addCriterion("assets_impair_loss is not null");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossEqualTo(Float value) {
            addCriterion("assets_impair_loss =", value, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossNotEqualTo(Float value) {
            addCriterion("assets_impair_loss <>", value, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossGreaterThan(Float value) {
            addCriterion("assets_impair_loss >", value, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossGreaterThanOrEqualTo(Float value) {
            addCriterion("assets_impair_loss >=", value, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossLessThan(Float value) {
            addCriterion("assets_impair_loss <", value, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossLessThanOrEqualTo(Float value) {
            addCriterion("assets_impair_loss <=", value, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossIn(List<Float> values) {
            addCriterion("assets_impair_loss in", values, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossNotIn(List<Float> values) {
            addCriterion("assets_impair_loss not in", values, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossBetween(Float value1, Float value2) {
            addCriterion("assets_impair_loss between", value1, value2, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andAssetsImpairLossNotBetween(Float value1, Float value2) {
            addCriterion("assets_impair_loss not between", value1, value2, "assetsImpairLoss");
            return (Criteria) this;
        }

        public Criteria andPremRefundIsNull() {
            addCriterion("prem_refund is null");
            return (Criteria) this;
        }

        public Criteria andPremRefundIsNotNull() {
            addCriterion("prem_refund is not null");
            return (Criteria) this;
        }

        public Criteria andPremRefundEqualTo(Float value) {
            addCriterion("prem_refund =", value, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundNotEqualTo(Float value) {
            addCriterion("prem_refund <>", value, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundGreaterThan(Float value) {
            addCriterion("prem_refund >", value, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundGreaterThanOrEqualTo(Float value) {
            addCriterion("prem_refund >=", value, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundLessThan(Float value) {
            addCriterion("prem_refund <", value, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundLessThanOrEqualTo(Float value) {
            addCriterion("prem_refund <=", value, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundIn(List<Float> values) {
            addCriterion("prem_refund in", values, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundNotIn(List<Float> values) {
            addCriterion("prem_refund not in", values, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundBetween(Float value1, Float value2) {
            addCriterion("prem_refund between", value1, value2, "premRefund");
            return (Criteria) this;
        }

        public Criteria andPremRefundNotBetween(Float value1, Float value2) {
            addCriterion("prem_refund not between", value1, value2, "premRefund");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutIsNull() {
            addCriterion("compens_payout is null");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutIsNotNull() {
            addCriterion("compens_payout is not null");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutEqualTo(Float value) {
            addCriterion("compens_payout =", value, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutNotEqualTo(Float value) {
            addCriterion("compens_payout <>", value, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutGreaterThan(Float value) {
            addCriterion("compens_payout >", value, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutGreaterThanOrEqualTo(Float value) {
            addCriterion("compens_payout >=", value, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutLessThan(Float value) {
            addCriterion("compens_payout <", value, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutLessThanOrEqualTo(Float value) {
            addCriterion("compens_payout <=", value, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutIn(List<Float> values) {
            addCriterion("compens_payout in", values, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutNotIn(List<Float> values) {
            addCriterion("compens_payout not in", values, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutBetween(Float value1, Float value2) {
            addCriterion("compens_payout between", value1, value2, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutNotBetween(Float value1, Float value2) {
            addCriterion("compens_payout not between", value1, value2, "compensPayout");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabIsNull() {
            addCriterion("reser_insur_liab is null");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabIsNotNull() {
            addCriterion("reser_insur_liab is not null");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabEqualTo(Float value) {
            addCriterion("reser_insur_liab =", value, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabNotEqualTo(Float value) {
            addCriterion("reser_insur_liab <>", value, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabGreaterThan(Float value) {
            addCriterion("reser_insur_liab >", value, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabGreaterThanOrEqualTo(Float value) {
            addCriterion("reser_insur_liab >=", value, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabLessThan(Float value) {
            addCriterion("reser_insur_liab <", value, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabLessThanOrEqualTo(Float value) {
            addCriterion("reser_insur_liab <=", value, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabIn(List<Float> values) {
            addCriterion("reser_insur_liab in", values, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabNotIn(List<Float> values) {
            addCriterion("reser_insur_liab not in", values, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabBetween(Float value1, Float value2) {
            addCriterion("reser_insur_liab between", value1, value2, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andReserInsurLiabNotBetween(Float value1, Float value2) {
            addCriterion("reser_insur_liab not between", value1, value2, "reserInsurLiab");
            return (Criteria) this;
        }

        public Criteria andDivPaytIsNull() {
            addCriterion("div_payt is null");
            return (Criteria) this;
        }

        public Criteria andDivPaytIsNotNull() {
            addCriterion("div_payt is not null");
            return (Criteria) this;
        }

        public Criteria andDivPaytEqualTo(Float value) {
            addCriterion("div_payt =", value, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytNotEqualTo(Float value) {
            addCriterion("div_payt <>", value, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytGreaterThan(Float value) {
            addCriterion("div_payt >", value, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytGreaterThanOrEqualTo(Float value) {
            addCriterion("div_payt >=", value, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytLessThan(Float value) {
            addCriterion("div_payt <", value, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytLessThanOrEqualTo(Float value) {
            addCriterion("div_payt <=", value, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytIn(List<Float> values) {
            addCriterion("div_payt in", values, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytNotIn(List<Float> values) {
            addCriterion("div_payt not in", values, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytBetween(Float value1, Float value2) {
            addCriterion("div_payt between", value1, value2, "divPayt");
            return (Criteria) this;
        }

        public Criteria andDivPaytNotBetween(Float value1, Float value2) {
            addCriterion("div_payt not between", value1, value2, "divPayt");
            return (Criteria) this;
        }

        public Criteria andReinsExpIsNull() {
            addCriterion("reins_exp is null");
            return (Criteria) this;
        }

        public Criteria andReinsExpIsNotNull() {
            addCriterion("reins_exp is not null");
            return (Criteria) this;
        }

        public Criteria andReinsExpEqualTo(Float value) {
            addCriterion("reins_exp =", value, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpNotEqualTo(Float value) {
            addCriterion("reins_exp <>", value, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpGreaterThan(Float value) {
            addCriterion("reins_exp >", value, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpGreaterThanOrEqualTo(Float value) {
            addCriterion("reins_exp >=", value, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpLessThan(Float value) {
            addCriterion("reins_exp <", value, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpLessThanOrEqualTo(Float value) {
            addCriterion("reins_exp <=", value, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpIn(List<Float> values) {
            addCriterion("reins_exp in", values, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpNotIn(List<Float> values) {
            addCriterion("reins_exp not in", values, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpBetween(Float value1, Float value2) {
            addCriterion("reins_exp between", value1, value2, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andReinsExpNotBetween(Float value1, Float value2) {
            addCriterion("reins_exp not between", value1, value2, "reinsExp");
            return (Criteria) this;
        }

        public Criteria andOperExpIsNull() {
            addCriterion("oper_exp is null");
            return (Criteria) this;
        }

        public Criteria andOperExpIsNotNull() {
            addCriterion("oper_exp is not null");
            return (Criteria) this;
        }

        public Criteria andOperExpEqualTo(Float value) {
            addCriterion("oper_exp =", value, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpNotEqualTo(Float value) {
            addCriterion("oper_exp <>", value, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpGreaterThan(Float value) {
            addCriterion("oper_exp >", value, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpGreaterThanOrEqualTo(Float value) {
            addCriterion("oper_exp >=", value, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpLessThan(Float value) {
            addCriterion("oper_exp <", value, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpLessThanOrEqualTo(Float value) {
            addCriterion("oper_exp <=", value, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpIn(List<Float> values) {
            addCriterion("oper_exp in", values, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpNotIn(List<Float> values) {
            addCriterion("oper_exp not in", values, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpBetween(Float value1, Float value2) {
            addCriterion("oper_exp between", value1, value2, "operExp");
            return (Criteria) this;
        }

        public Criteria andOperExpNotBetween(Float value1, Float value2) {
            addCriterion("oper_exp not between", value1, value2, "operExp");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuIsNull() {
            addCriterion("compens_payout_refu is null");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuIsNotNull() {
            addCriterion("compens_payout_refu is not null");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuEqualTo(Float value) {
            addCriterion("compens_payout_refu =", value, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuNotEqualTo(Float value) {
            addCriterion("compens_payout_refu <>", value, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuGreaterThan(Float value) {
            addCriterion("compens_payout_refu >", value, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuGreaterThanOrEqualTo(Float value) {
            addCriterion("compens_payout_refu >=", value, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuLessThan(Float value) {
            addCriterion("compens_payout_refu <", value, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuLessThanOrEqualTo(Float value) {
            addCriterion("compens_payout_refu <=", value, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuIn(List<Float> values) {
            addCriterion("compens_payout_refu in", values, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuNotIn(List<Float> values) {
            addCriterion("compens_payout_refu not in", values, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuBetween(Float value1, Float value2) {
            addCriterion("compens_payout_refu between", value1, value2, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andCompensPayoutRefuNotBetween(Float value1, Float value2) {
            addCriterion("compens_payout_refu not between", value1, value2, "compensPayoutRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuIsNull() {
            addCriterion("insur_reser_refu is null");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuIsNotNull() {
            addCriterion("insur_reser_refu is not null");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuEqualTo(Float value) {
            addCriterion("insur_reser_refu =", value, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuNotEqualTo(Float value) {
            addCriterion("insur_reser_refu <>", value, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuGreaterThan(Float value) {
            addCriterion("insur_reser_refu >", value, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuGreaterThanOrEqualTo(Float value) {
            addCriterion("insur_reser_refu >=", value, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuLessThan(Float value) {
            addCriterion("insur_reser_refu <", value, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuLessThanOrEqualTo(Float value) {
            addCriterion("insur_reser_refu <=", value, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuIn(List<Float> values) {
            addCriterion("insur_reser_refu in", values, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuNotIn(List<Float> values) {
            addCriterion("insur_reser_refu not in", values, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuBetween(Float value1, Float value2) {
            addCriterion("insur_reser_refu between", value1, value2, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andInsurReserRefuNotBetween(Float value1, Float value2) {
            addCriterion("insur_reser_refu not between", value1, value2, "insurReserRefu");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundIsNull() {
            addCriterion("reins_cost_refund is null");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundIsNotNull() {
            addCriterion("reins_cost_refund is not null");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundEqualTo(Float value) {
            addCriterion("reins_cost_refund =", value, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundNotEqualTo(Float value) {
            addCriterion("reins_cost_refund <>", value, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundGreaterThan(Float value) {
            addCriterion("reins_cost_refund >", value, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundGreaterThanOrEqualTo(Float value) {
            addCriterion("reins_cost_refund >=", value, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundLessThan(Float value) {
            addCriterion("reins_cost_refund <", value, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundLessThanOrEqualTo(Float value) {
            addCriterion("reins_cost_refund <=", value, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundIn(List<Float> values) {
            addCriterion("reins_cost_refund in", values, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundNotIn(List<Float> values) {
            addCriterion("reins_cost_refund not in", values, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundBetween(Float value1, Float value2) {
            addCriterion("reins_cost_refund between", value1, value2, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andReinsCostRefundNotBetween(Float value1, Float value2) {
            addCriterion("reins_cost_refund not between", value1, value2, "reinsCostRefund");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostIsNull() {
            addCriterion("other_bus_cost is null");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostIsNotNull() {
            addCriterion("other_bus_cost is not null");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostEqualTo(Float value) {
            addCriterion("other_bus_cost =", value, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostNotEqualTo(Float value) {
            addCriterion("other_bus_cost <>", value, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostGreaterThan(Float value) {
            addCriterion("other_bus_cost >", value, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostGreaterThanOrEqualTo(Float value) {
            addCriterion("other_bus_cost >=", value, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostLessThan(Float value) {
            addCriterion("other_bus_cost <", value, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostLessThanOrEqualTo(Float value) {
            addCriterion("other_bus_cost <=", value, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostIn(List<Float> values) {
            addCriterion("other_bus_cost in", values, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostNotIn(List<Float> values) {
            addCriterion("other_bus_cost not in", values, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostBetween(Float value1, Float value2) {
            addCriterion("other_bus_cost between", value1, value2, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOtherBusCostNotBetween(Float value1, Float value2) {
            addCriterion("other_bus_cost not between", value1, value2, "otherBusCost");
            return (Criteria) this;
        }

        public Criteria andOperateProfitIsNull() {
            addCriterion("operate_profit is null");
            return (Criteria) this;
        }

        public Criteria andOperateProfitIsNotNull() {
            addCriterion("operate_profit is not null");
            return (Criteria) this;
        }

        public Criteria andOperateProfitEqualTo(Float value) {
            addCriterion("operate_profit =", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitNotEqualTo(Float value) {
            addCriterion("operate_profit <>", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitGreaterThan(Float value) {
            addCriterion("operate_profit >", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitGreaterThanOrEqualTo(Float value) {
            addCriterion("operate_profit >=", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitLessThan(Float value) {
            addCriterion("operate_profit <", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitLessThanOrEqualTo(Float value) {
            addCriterion("operate_profit <=", value, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitIn(List<Float> values) {
            addCriterion("operate_profit in", values, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitNotIn(List<Float> values) {
            addCriterion("operate_profit not in", values, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitBetween(Float value1, Float value2) {
            addCriterion("operate_profit between", value1, value2, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andOperateProfitNotBetween(Float value1, Float value2) {
            addCriterion("operate_profit not between", value1, value2, "operateProfit");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeIsNull() {
            addCriterion("non_oper_income is null");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeIsNotNull() {
            addCriterion("non_oper_income is not null");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeEqualTo(Float value) {
            addCriterion("non_oper_income =", value, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeNotEqualTo(Float value) {
            addCriterion("non_oper_income <>", value, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeGreaterThan(Float value) {
            addCriterion("non_oper_income >", value, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("non_oper_income >=", value, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeLessThan(Float value) {
            addCriterion("non_oper_income <", value, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeLessThanOrEqualTo(Float value) {
            addCriterion("non_oper_income <=", value, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeIn(List<Float> values) {
            addCriterion("non_oper_income in", values, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeNotIn(List<Float> values) {
            addCriterion("non_oper_income not in", values, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeBetween(Float value1, Float value2) {
            addCriterion("non_oper_income between", value1, value2, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperIncomeNotBetween(Float value1, Float value2) {
            addCriterion("non_oper_income not between", value1, value2, "nonOperIncome");
            return (Criteria) this;
        }

        public Criteria andNonOperExpIsNull() {
            addCriterion("non_oper_exp is null");
            return (Criteria) this;
        }

        public Criteria andNonOperExpIsNotNull() {
            addCriterion("non_oper_exp is not null");
            return (Criteria) this;
        }

        public Criteria andNonOperExpEqualTo(Float value) {
            addCriterion("non_oper_exp =", value, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpNotEqualTo(Float value) {
            addCriterion("non_oper_exp <>", value, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpGreaterThan(Float value) {
            addCriterion("non_oper_exp >", value, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpGreaterThanOrEqualTo(Float value) {
            addCriterion("non_oper_exp >=", value, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpLessThan(Float value) {
            addCriterion("non_oper_exp <", value, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpLessThanOrEqualTo(Float value) {
            addCriterion("non_oper_exp <=", value, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpIn(List<Float> values) {
            addCriterion("non_oper_exp in", values, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpNotIn(List<Float> values) {
            addCriterion("non_oper_exp not in", values, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpBetween(Float value1, Float value2) {
            addCriterion("non_oper_exp between", value1, value2, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNonOperExpNotBetween(Float value1, Float value2) {
            addCriterion("non_oper_exp not between", value1, value2, "nonOperExp");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossIsNull() {
            addCriterion("nca_disploss is null");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossIsNotNull() {
            addCriterion("nca_disploss is not null");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossEqualTo(Float value) {
            addCriterion("nca_disploss =", value, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossNotEqualTo(Float value) {
            addCriterion("nca_disploss <>", value, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossGreaterThan(Float value) {
            addCriterion("nca_disploss >", value, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossGreaterThanOrEqualTo(Float value) {
            addCriterion("nca_disploss >=", value, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossLessThan(Float value) {
            addCriterion("nca_disploss <", value, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossLessThanOrEqualTo(Float value) {
            addCriterion("nca_disploss <=", value, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossIn(List<Float> values) {
            addCriterion("nca_disploss in", values, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossNotIn(List<Float> values) {
            addCriterion("nca_disploss not in", values, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossBetween(Float value1, Float value2) {
            addCriterion("nca_disploss between", value1, value2, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andNcaDisplossNotBetween(Float value1, Float value2) {
            addCriterion("nca_disploss not between", value1, value2, "ncaDisploss");
            return (Criteria) this;
        }

        public Criteria andTotalProfitIsNull() {
            addCriterion("total_profit is null");
            return (Criteria) this;
        }

        public Criteria andTotalProfitIsNotNull() {
            addCriterion("total_profit is not null");
            return (Criteria) this;
        }

        public Criteria andTotalProfitEqualTo(Float value) {
            addCriterion("total_profit =", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitNotEqualTo(Float value) {
            addCriterion("total_profit <>", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitGreaterThan(Float value) {
            addCriterion("total_profit >", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitGreaterThanOrEqualTo(Float value) {
            addCriterion("total_profit >=", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitLessThan(Float value) {
            addCriterion("total_profit <", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitLessThanOrEqualTo(Float value) {
            addCriterion("total_profit <=", value, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitIn(List<Float> values) {
            addCriterion("total_profit in", values, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitNotIn(List<Float> values) {
            addCriterion("total_profit not in", values, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitBetween(Float value1, Float value2) {
            addCriterion("total_profit between", value1, value2, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andTotalProfitNotBetween(Float value1, Float value2) {
            addCriterion("total_profit not between", value1, value2, "totalProfit");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxIsNull() {
            addCriterion("income_tax is null");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxIsNotNull() {
            addCriterion("income_tax is not null");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxEqualTo(Float value) {
            addCriterion("income_tax =", value, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxNotEqualTo(Float value) {
            addCriterion("income_tax <>", value, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxGreaterThan(Float value) {
            addCriterion("income_tax >", value, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxGreaterThanOrEqualTo(Float value) {
            addCriterion("income_tax >=", value, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxLessThan(Float value) {
            addCriterion("income_tax <", value, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxLessThanOrEqualTo(Float value) {
            addCriterion("income_tax <=", value, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxIn(List<Float> values) {
            addCriterion("income_tax in", values, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxNotIn(List<Float> values) {
            addCriterion("income_tax not in", values, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxBetween(Float value1, Float value2) {
            addCriterion("income_tax between", value1, value2, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andIncomeTaxNotBetween(Float value1, Float value2) {
            addCriterion("income_tax not between", value1, value2, "incomeTax");
            return (Criteria) this;
        }

        public Criteria andNIncomeIsNull() {
            addCriterion("n_income is null");
            return (Criteria) this;
        }

        public Criteria andNIncomeIsNotNull() {
            addCriterion("n_income is not null");
            return (Criteria) this;
        }

        public Criteria andNIncomeEqualTo(Float value) {
            addCriterion("n_income =", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeNotEqualTo(Float value) {
            addCriterion("n_income <>", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeGreaterThan(Float value) {
            addCriterion("n_income >", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("n_income >=", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeLessThan(Float value) {
            addCriterion("n_income <", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeLessThanOrEqualTo(Float value) {
            addCriterion("n_income <=", value, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeIn(List<Float> values) {
            addCriterion("n_income in", values, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeNotIn(List<Float> values) {
            addCriterion("n_income not in", values, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeBetween(Float value1, Float value2) {
            addCriterion("n_income between", value1, value2, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeNotBetween(Float value1, Float value2) {
            addCriterion("n_income not between", value1, value2, "nIncome");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPIsNull() {
            addCriterion("n_income_attr_p is null");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPIsNotNull() {
            addCriterion("n_income_attr_p is not null");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPEqualTo(Float value) {
            addCriterion("n_income_attr_p =", value, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPNotEqualTo(Float value) {
            addCriterion("n_income_attr_p <>", value, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPGreaterThan(Float value) {
            addCriterion("n_income_attr_p >", value, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPGreaterThanOrEqualTo(Float value) {
            addCriterion("n_income_attr_p >=", value, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPLessThan(Float value) {
            addCriterion("n_income_attr_p <", value, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPLessThanOrEqualTo(Float value) {
            addCriterion("n_income_attr_p <=", value, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPIn(List<Float> values) {
            addCriterion("n_income_attr_p in", values, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPNotIn(List<Float> values) {
            addCriterion("n_income_attr_p not in", values, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPBetween(Float value1, Float value2) {
            addCriterion("n_income_attr_p between", value1, value2, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andNIncomeAttrPNotBetween(Float value1, Float value2) {
            addCriterion("n_income_attr_p not between", value1, value2, "nIncomeAttrP");
            return (Criteria) this;
        }

        public Criteria andMinorityGainIsNull() {
            addCriterion("minority_gain is null");
            return (Criteria) this;
        }

        public Criteria andMinorityGainIsNotNull() {
            addCriterion("minority_gain is not null");
            return (Criteria) this;
        }

        public Criteria andMinorityGainEqualTo(Float value) {
            addCriterion("minority_gain =", value, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainNotEqualTo(Float value) {
            addCriterion("minority_gain <>", value, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainGreaterThan(Float value) {
            addCriterion("minority_gain >", value, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainGreaterThanOrEqualTo(Float value) {
            addCriterion("minority_gain >=", value, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainLessThan(Float value) {
            addCriterion("minority_gain <", value, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainLessThanOrEqualTo(Float value) {
            addCriterion("minority_gain <=", value, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainIn(List<Float> values) {
            addCriterion("minority_gain in", values, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainNotIn(List<Float> values) {
            addCriterion("minority_gain not in", values, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainBetween(Float value1, Float value2) {
            addCriterion("minority_gain between", value1, value2, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andMinorityGainNotBetween(Float value1, Float value2) {
            addCriterion("minority_gain not between", value1, value2, "minorityGain");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeIsNull() {
            addCriterion("oth_compr_income is null");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeIsNotNull() {
            addCriterion("oth_compr_income is not null");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeEqualTo(Float value) {
            addCriterion("oth_compr_income =", value, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeNotEqualTo(Float value) {
            addCriterion("oth_compr_income <>", value, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeGreaterThan(Float value) {
            addCriterion("oth_compr_income >", value, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("oth_compr_income >=", value, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeLessThan(Float value) {
            addCriterion("oth_compr_income <", value, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeLessThanOrEqualTo(Float value) {
            addCriterion("oth_compr_income <=", value, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeIn(List<Float> values) {
            addCriterion("oth_compr_income in", values, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeNotIn(List<Float> values) {
            addCriterion("oth_compr_income not in", values, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeBetween(Float value1, Float value2) {
            addCriterion("oth_compr_income between", value1, value2, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andOthComprIncomeNotBetween(Float value1, Float value2) {
            addCriterion("oth_compr_income not between", value1, value2, "othComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeIsNull() {
            addCriterion("t_compr_income is null");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeIsNotNull() {
            addCriterion("t_compr_income is not null");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeEqualTo(Float value) {
            addCriterion("t_compr_income =", value, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeNotEqualTo(Float value) {
            addCriterion("t_compr_income <>", value, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeGreaterThan(Float value) {
            addCriterion("t_compr_income >", value, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeGreaterThanOrEqualTo(Float value) {
            addCriterion("t_compr_income >=", value, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeLessThan(Float value) {
            addCriterion("t_compr_income <", value, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeLessThanOrEqualTo(Float value) {
            addCriterion("t_compr_income <=", value, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeIn(List<Float> values) {
            addCriterion("t_compr_income in", values, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeNotIn(List<Float> values) {
            addCriterion("t_compr_income not in", values, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeBetween(Float value1, Float value2) {
            addCriterion("t_compr_income between", value1, value2, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andTComprIncomeNotBetween(Float value1, Float value2) {
            addCriterion("t_compr_income not between", value1, value2, "tComprIncome");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPIsNull() {
            addCriterion("compr_inc_attr_p is null");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPIsNotNull() {
            addCriterion("compr_inc_attr_p is not null");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPEqualTo(Float value) {
            addCriterion("compr_inc_attr_p =", value, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPNotEqualTo(Float value) {
            addCriterion("compr_inc_attr_p <>", value, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPGreaterThan(Float value) {
            addCriterion("compr_inc_attr_p >", value, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPGreaterThanOrEqualTo(Float value) {
            addCriterion("compr_inc_attr_p >=", value, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPLessThan(Float value) {
            addCriterion("compr_inc_attr_p <", value, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPLessThanOrEqualTo(Float value) {
            addCriterion("compr_inc_attr_p <=", value, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPIn(List<Float> values) {
            addCriterion("compr_inc_attr_p in", values, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPNotIn(List<Float> values) {
            addCriterion("compr_inc_attr_p not in", values, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPBetween(Float value1, Float value2) {
            addCriterion("compr_inc_attr_p between", value1, value2, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrPNotBetween(Float value1, Float value2) {
            addCriterion("compr_inc_attr_p not between", value1, value2, "comprIncAttrP");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSIsNull() {
            addCriterion("compr_inc_attr_m_s is null");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSIsNotNull() {
            addCriterion("compr_inc_attr_m_s is not null");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSEqualTo(Float value) {
            addCriterion("compr_inc_attr_m_s =", value, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSNotEqualTo(Float value) {
            addCriterion("compr_inc_attr_m_s <>", value, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSGreaterThan(Float value) {
            addCriterion("compr_inc_attr_m_s >", value, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSGreaterThanOrEqualTo(Float value) {
            addCriterion("compr_inc_attr_m_s >=", value, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSLessThan(Float value) {
            addCriterion("compr_inc_attr_m_s <", value, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSLessThanOrEqualTo(Float value) {
            addCriterion("compr_inc_attr_m_s <=", value, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSIn(List<Float> values) {
            addCriterion("compr_inc_attr_m_s in", values, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSNotIn(List<Float> values) {
            addCriterion("compr_inc_attr_m_s not in", values, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSBetween(Float value1, Float value2) {
            addCriterion("compr_inc_attr_m_s between", value1, value2, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andComprIncAttrMSNotBetween(Float value1, Float value2) {
            addCriterion("compr_inc_attr_m_s not between", value1, value2, "comprIncAttrMS");
            return (Criteria) this;
        }

        public Criteria andEbitIsNull() {
            addCriterion("ebit is null");
            return (Criteria) this;
        }

        public Criteria andEbitIsNotNull() {
            addCriterion("ebit is not null");
            return (Criteria) this;
        }

        public Criteria andEbitEqualTo(Float value) {
            addCriterion("ebit =", value, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitNotEqualTo(Float value) {
            addCriterion("ebit <>", value, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitGreaterThan(Float value) {
            addCriterion("ebit >", value, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitGreaterThanOrEqualTo(Float value) {
            addCriterion("ebit >=", value, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitLessThan(Float value) {
            addCriterion("ebit <", value, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitLessThanOrEqualTo(Float value) {
            addCriterion("ebit <=", value, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitIn(List<Float> values) {
            addCriterion("ebit in", values, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitNotIn(List<Float> values) {
            addCriterion("ebit not in", values, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitBetween(Float value1, Float value2) {
            addCriterion("ebit between", value1, value2, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitNotBetween(Float value1, Float value2) {
            addCriterion("ebit not between", value1, value2, "ebit");
            return (Criteria) this;
        }

        public Criteria andEbitdaIsNull() {
            addCriterion("ebitda is null");
            return (Criteria) this;
        }

        public Criteria andEbitdaIsNotNull() {
            addCriterion("ebitda is not null");
            return (Criteria) this;
        }

        public Criteria andEbitdaEqualTo(Float value) {
            addCriterion("ebitda =", value, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaNotEqualTo(Float value) {
            addCriterion("ebitda <>", value, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaGreaterThan(Float value) {
            addCriterion("ebitda >", value, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaGreaterThanOrEqualTo(Float value) {
            addCriterion("ebitda >=", value, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaLessThan(Float value) {
            addCriterion("ebitda <", value, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaLessThanOrEqualTo(Float value) {
            addCriterion("ebitda <=", value, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaIn(List<Float> values) {
            addCriterion("ebitda in", values, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaNotIn(List<Float> values) {
            addCriterion("ebitda not in", values, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaBetween(Float value1, Float value2) {
            addCriterion("ebitda between", value1, value2, "ebitda");
            return (Criteria) this;
        }

        public Criteria andEbitdaNotBetween(Float value1, Float value2) {
            addCriterion("ebitda not between", value1, value2, "ebitda");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpIsNull() {
            addCriterion("insurance_exp is null");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpIsNotNull() {
            addCriterion("insurance_exp is not null");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpEqualTo(Float value) {
            addCriterion("insurance_exp =", value, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpNotEqualTo(Float value) {
            addCriterion("insurance_exp <>", value, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpGreaterThan(Float value) {
            addCriterion("insurance_exp >", value, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpGreaterThanOrEqualTo(Float value) {
            addCriterion("insurance_exp >=", value, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpLessThan(Float value) {
            addCriterion("insurance_exp <", value, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpLessThanOrEqualTo(Float value) {
            addCriterion("insurance_exp <=", value, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpIn(List<Float> values) {
            addCriterion("insurance_exp in", values, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpNotIn(List<Float> values) {
            addCriterion("insurance_exp not in", values, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpBetween(Float value1, Float value2) {
            addCriterion("insurance_exp between", value1, value2, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andInsuranceExpNotBetween(Float value1, Float value2) {
            addCriterion("insurance_exp not between", value1, value2, "insuranceExp");
            return (Criteria) this;
        }

        public Criteria andUndistProfitIsNull() {
            addCriterion("undist_profit is null");
            return (Criteria) this;
        }

        public Criteria andUndistProfitIsNotNull() {
            addCriterion("undist_profit is not null");
            return (Criteria) this;
        }

        public Criteria andUndistProfitEqualTo(Float value) {
            addCriterion("undist_profit =", value, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitNotEqualTo(Float value) {
            addCriterion("undist_profit <>", value, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitGreaterThan(Float value) {
            addCriterion("undist_profit >", value, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitGreaterThanOrEqualTo(Float value) {
            addCriterion("undist_profit >=", value, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitLessThan(Float value) {
            addCriterion("undist_profit <", value, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitLessThanOrEqualTo(Float value) {
            addCriterion("undist_profit <=", value, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitIn(List<Float> values) {
            addCriterion("undist_profit in", values, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitNotIn(List<Float> values) {
            addCriterion("undist_profit not in", values, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitBetween(Float value1, Float value2) {
            addCriterion("undist_profit between", value1, value2, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andUndistProfitNotBetween(Float value1, Float value2) {
            addCriterion("undist_profit not between", value1, value2, "undistProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitIsNull() {
            addCriterion("distable_profit is null");
            return (Criteria) this;
        }

        public Criteria andDistableProfitIsNotNull() {
            addCriterion("distable_profit is not null");
            return (Criteria) this;
        }

        public Criteria andDistableProfitEqualTo(Float value) {
            addCriterion("distable_profit =", value, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitNotEqualTo(Float value) {
            addCriterion("distable_profit <>", value, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitGreaterThan(Float value) {
            addCriterion("distable_profit >", value, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitGreaterThanOrEqualTo(Float value) {
            addCriterion("distable_profit >=", value, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitLessThan(Float value) {
            addCriterion("distable_profit <", value, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitLessThanOrEqualTo(Float value) {
            addCriterion("distable_profit <=", value, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitIn(List<Float> values) {
            addCriterion("distable_profit in", values, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitNotIn(List<Float> values) {
            addCriterion("distable_profit not in", values, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitBetween(Float value1, Float value2) {
            addCriterion("distable_profit between", value1, value2, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andDistableProfitNotBetween(Float value1, Float value2) {
            addCriterion("distable_profit not between", value1, value2, "distableProfit");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagIsNull() {
            addCriterion("update_flag is null");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagIsNotNull() {
            addCriterion("update_flag is not null");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagEqualTo(String value) {
            addCriterion("update_flag =", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotEqualTo(String value) {
            addCriterion("update_flag <>", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagGreaterThan(String value) {
            addCriterion("update_flag >", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagGreaterThanOrEqualTo(String value) {
            addCriterion("update_flag >=", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagLessThan(String value) {
            addCriterion("update_flag <", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagLessThanOrEqualTo(String value) {
            addCriterion("update_flag <=", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagLike(String value) {
            addCriterion("update_flag like", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotLike(String value) {
            addCriterion("update_flag not like", value, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagIn(List<String> values) {
            addCriterion("update_flag in", values, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotIn(List<String> values) {
            addCriterion("update_flag not in", values, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagBetween(String value1, String value2) {
            addCriterion("update_flag between", value1, value2, "updateFlag");
            return (Criteria) this;
        }

        public Criteria andUpdateFlagNotBetween(String value1, String value2) {
            addCriterion("update_flag not between", value1, value2, "updateFlag");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}